home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / PIL / ImageOps.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  7KB  |  247 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import Image
  5. import operator
  6.  
  7. def _border(border):
  8.     if type(border) is type(()):
  9.         if len(border) == 2:
  10.             (left, top) = (right, bottom) = border
  11.         elif len(border) == 4:
  12.             (left, top, right, bottom) = border
  13.         
  14.     else:
  15.         left = top = right = bottom = border
  16.     return (left, top, right, bottom)
  17.  
  18.  
  19. def _color(color, mode):
  20.     if Image.isStringType(color):
  21.         import ImageColor as ImageColor
  22.         color = ImageColor.getcolor(color, mode)
  23.     
  24.     return color
  25.  
  26.  
  27. def _lut(image, lut):
  28.     if image.mode == 'P':
  29.         raise NotImplementedError('mode P support coming soon')
  30.     elif image.mode in ('L', 'RGB'):
  31.         if image.mode == 'RGB' and len(lut) == 256:
  32.             lut = lut + lut + lut
  33.         
  34.         return image.point(lut)
  35.     else:
  36.         raise IOError, 'not supported for this image mode'
  37.  
  38.  
  39. def autocontrast(image, cutoff = 0, ignore = None):
  40.     histogram = image.histogram()
  41.     lut = []
  42.     for layer in range(0, len(histogram), 256):
  43.         h = histogram[layer:layer + 256]
  44.         if ignore is not None:
  45.             
  46.             try:
  47.                 h[ignore] = 0
  48.             except TypeError:
  49.                 for ix in ignore:
  50.                     h[ix] = 0
  51.                 
  52.             
  53.  
  54.         None<EXCEPTION MATCH>TypeError
  55.         if cutoff:
  56.             n = 0
  57.             for ix in range(256):
  58.                 n = n + h[ix]
  59.             
  60.             cut = n * cutoff / 100
  61.             for lo in range(256):
  62.                 if cut > h[lo]:
  63.                     cut = cut - h[lo]
  64.                     h[lo] = 0
  65.                 else:
  66.                     h[lo] = h[lo] - cut
  67.                     cut = 0
  68.                 if cut <= 0:
  69.                     break
  70.                     continue
  71.             
  72.             cut = n * cutoff / 100
  73.             for hi in range(255, -1, -1):
  74.                 if cut > h[hi]:
  75.                     cut = cut - h[hi]
  76.                     h[hi] = 0
  77.                 else:
  78.                     h[hi] = h[hi] - cut
  79.                     cut = 0
  80.                 if cut <= 0:
  81.                     break
  82.                     continue
  83.             
  84.         
  85.         for lo in range(256):
  86.             if h[lo]:
  87.                 break
  88.                 continue
  89.         
  90.         for hi in range(255, -1, -1):
  91.             if h[hi]:
  92.                 break
  93.                 continue
  94.         
  95.         if hi <= lo:
  96.             lut.extend(range(256))
  97.             continue
  98.         scale = 255 / (hi - lo)
  99.         offset = -lo * scale
  100.         for ix in range(256):
  101.             ix = int(ix * scale + offset)
  102.             if ix < 0:
  103.                 ix = 0
  104.             elif ix > 255:
  105.                 ix = 255
  106.             
  107.             lut.append(ix)
  108.         
  109.     
  110.     return _lut(image, lut)
  111.  
  112.  
  113. def colorize(image, black, white):
  114.     black = _color(black, 'RGB')
  115.     white = _color(white, 'RGB')
  116.     red = []
  117.     green = []
  118.     blue = []
  119.     for i in range(256):
  120.         red.append(black[0] + i * (white[0] - black[0]) / 255)
  121.         green.append(black[1] + i * (white[1] - black[1]) / 255)
  122.         blue.append(black[2] + i * (white[2] - black[2]) / 255)
  123.     
  124.     image = image.convert('RGB')
  125.     return _lut(image, red + green + blue)
  126.  
  127.  
  128. def crop(image, border = 0):
  129.     (left, top, right, bottom) = _border(border)
  130.     return image.crop((left, top, image.size[0] - right, image.size[1] - bottom))
  131.  
  132.  
  133. def deform(image, deformer, resample = Image.BILINEAR):
  134.     return image.transform(image.size, Image.MESH, deformer.getmesh(image), resample)
  135.  
  136.  
  137. def equalize(image, mask = None):
  138.     if image.mode == 'P':
  139.         image = image.convert('RGB')
  140.     
  141.     h = image.histogram(mask)
  142.     lut = []
  143.     for b in range(0, len(h), 256):
  144.         histo = filter(None, h[b:b + 256])
  145.         if len(histo) <= 1:
  146.             lut.extend(range(256))
  147.             continue
  148.         step = (reduce(operator.add, histo) - histo[-1]) / 255
  149.         if not step:
  150.             lut.extend(range(256))
  151.             continue
  152.         n = step / 2
  153.         for i in range(256):
  154.             lut.append(n / step)
  155.             n = n + h[i + b]
  156.         
  157.     
  158.     return _lut(image, lut)
  159.  
  160.  
  161. def expand(image, border = 0, fill = 0):
  162.     (left, top, right, bottom) = _border(border)
  163.     width = left + image.size[0] + right
  164.     height = top + image.size[1] + bottom
  165.     out = Image.new(image.mode, (width, height), _color(fill, image.mode))
  166.     out.paste(image, (left, top))
  167.     return out
  168.  
  169.  
  170. def fit(image, size, method = Image.NEAREST, bleed = 0, centering = (0.5, 0.5)):
  171.     if type(centering) != type([]):
  172.         centering = [
  173.             centering[0],
  174.             centering[1]]
  175.     
  176.     if centering[0] > 1 or centering[0] < 0:
  177.         centering[0] = 0.5
  178.     
  179.     if centering[1] > 1 or centering[1] < 0:
  180.         centering[1] = 0.5
  181.     
  182.     if bleed > 0.49999 or bleed < 0:
  183.         bleed = 0
  184.     
  185.     bleedPixels = (int(float(bleed) * float(image.size[0]) + 0.5), int(float(bleed) * float(image.size[1]) + 0.5))
  186.     liveArea = (bleedPixels[0], bleedPixels[1], image.size[0] - bleedPixels[0] - 1, image.size[1] - bleedPixels[1] - 1)
  187.     liveSize = (liveArea[2] - liveArea[0], liveArea[3] - liveArea[1])
  188.     liveAreaAspectRatio = float(liveSize[0]) / float(liveSize[1])
  189.     aspectRatio = float(size[0]) / float(size[1])
  190.     if liveAreaAspectRatio >= aspectRatio:
  191.         cropWidth = int(aspectRatio * float(liveSize[1]) + 0.5)
  192.         cropHeight = liveSize[1]
  193.     else:
  194.         cropWidth = liveSize[0]
  195.         cropHeight = int(float(liveSize[0]) / aspectRatio + 0.5)
  196.     leftSide = int(liveArea[0] + float(liveSize[0] - cropWidth) * centering[0])
  197.     if leftSide < 0:
  198.         leftSide = 0
  199.     
  200.     topSide = int(liveArea[1] + float(liveSize[1] - cropHeight) * centering[1])
  201.     if topSide < 0:
  202.         topSide = 0
  203.     
  204.     out = image.crop((leftSide, topSide, leftSide + cropWidth, topSide + cropHeight))
  205.     return out.resize(size, method)
  206.  
  207.  
  208. def flip(image):
  209.     return image.transpose(Image.FLIP_TOP_BOTTOM)
  210.  
  211.  
  212. def grayscale(image):
  213.     return image.convert('L')
  214.  
  215.  
  216. def invert(image):
  217.     lut = []
  218.     for i in range(256):
  219.         lut.append(255 - i)
  220.     
  221.     return _lut(image, lut)
  222.  
  223.  
  224. def mirror(image):
  225.     return image.transpose(Image.FLIP_LEFT_RIGHT)
  226.  
  227.  
  228. def posterize(image, bits):
  229.     lut = []
  230.     mask = ~(2 ** (8 - bits) - 1)
  231.     for i in range(256):
  232.         lut.append(i & mask)
  233.     
  234.     return _lut(image, lut)
  235.  
  236.  
  237. def solarize(image, threshold = 128):
  238.     lut = []
  239.     for i in range(256):
  240.         if i < threshold:
  241.             lut.append(i)
  242.             continue
  243.         lut.append(255 - i)
  244.     
  245.     return _lut(image, lut)
  246.  
  247.